home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / ada / ada_lrm1.zip / CHAPD.DOC < prev    next >
Text File  |  1988-11-30  |  21KB  |  860 lines
  1.  
  2.  
  3.  
  4.  
  5.  
  6. The following document is a draft  of  the  corresponding  chapter  of  the
  7. version  of  the  Ada  Reference  Manual  produced  in response to the Ansi
  8. Canvass.  It is given a limited circulation  to  Ada  implementers  and  to
  9. other groups contributing comments (according to the conventions defined in
  10. RRM.comments).  This draft should not be referred to in any publication.
  11.  
  12.  
  13.  
  14.                        ANSI-RM-D-v23 - Draft Chapter
  15.  
  16.                                 D Glossary
  17.                                 version 23
  18.  
  19.  
  20.                                  83-03-11
  21.  
  22.            This revision has considered all comments up to #5795
  23.  
  24.  
  25.  
  26.  
  27.  
  28.  
  29.  
  30.  
  31.  
  32.  
  33.  
  34.  
  35.  
  36.  
  37.  
  38.  
  39.  
  40.  
  41.  
  42.  
  43.  
  44.  
  45.  
  46.  
  47.  
  48.  
  49.  
  50.  
  51.  
  52.  
  53.  
  54.  
  55.  
  56.  
  57.  
  58.  
  59.  
  60.  
  61.  
  62.  
  63.  
  64.  
  65.  
  66.  
  67.  
  68.  
  69.  
  70.  
  71.  
  72.  
  73.  
  74.  
  75.  
  76.  
  77.                                 D. Glossary
  78.  
  79.  
  80.  
  81. This  appendix is informative and is not part of the standard definition of
  82. the  Ada  programming  language.   Italicized  terms  in  the   abbreviated
  83. descriptions below either have glossary entries themselves or are described
  84. in entries for related terms.
  85.  
  86. Accept statement.  See entry.
  87.  
  88. Access  type.  A value of an access type (an access value) is either a null
  89. value, or a value that designates an object created by an  allocator.   The
  90. designated  object  can  be  read  and  updated  via the access value.  The
  91. definition of an access type specifies the type of the  objects  designated
  92. by values of the access type.  See also collection.
  93.  
  94. Actual parameter.  See parameter.
  95.  
  96. Aggregate.   The  evaluation  of an aggregate yields a value of a composite
  97. type.  The  value  is  specified  by  giving  the  value  of  each  of  the
  98. components.  Either positional association or named association may be used
  99. to indicate which value is associated with which component.
  100.  
  101. Allocator.   The evaluation of an allocator creates an object and returns a
  102. new access value which designates the object.
  103.  
  104. Array type.  A value of an array type consists of components which are  all
  105. of  the  same  subtype  (and  hence,  of the same type).  Each component is
  106. uniquely distinguished by an index (for a one-dimensional array)  or  by  a
  107. sequence  of  indices (for a multidimensional array).  Each index must be a
  108. value of a discrete type and must lie in the correct index range.
  109.  
  110. Assignment.  Assignment is the operation that replaces the current value of
  111. a variable by a new value.  An assignment statement specifies a variable on
  112. the left, and on the right, an expression whose value  is  to  be  the  new
  113. value of the variable.
  114.  
  115. Attribute.    The   evaluation   of   an   attribute  yields  a  predefined
  116. characteristic of a named entity;  some attributes are functions.
  117.  
  118. Block statement.  A block statement is a single statement that may  contain
  119. a  sequence  of  statements.   It  may also include a declarative part, and
  120. exception handlers;  their effects are local to the block statement.
  121.  
  122. Body.  A body defines the execution of a subprogram, package, or  task.   A
  123. body  stub  is a form of body that indicates that this execution is defined
  124. in a separately compiled subunit.
  125.  
  126.  
  127.  
  128.  
  129.                                    D - 1
  130.  
  131.  
  132.  
  133.  
  134.  
  135.  
  136.  
  137.  
  138. Collection.   A  collection  is  the  entire  set  of  objects  created  by
  139. evaluation of allocators for an access type.
  140.  
  141. Compilation  unit.   A compilation unit is the declaration or the body of a
  142. program unit, presented for compilation as  an  independent  text.   It  is
  143. optionally  preceded  by  a  context clause, naming other compilation units
  144. upon which it depends by means of one more with clauses.
  145.  
  146. Component.  A component is a value that is a part of a larger value, or  an
  147. object that is part of a larger object.
  148.  
  149.  
  150.  
  151.  
  152.  
  153.  
  154.  
  155.  
  156.  
  157.  
  158.  
  159.  
  160.  
  161.  
  162.  
  163.  
  164.  
  165.  
  166.  
  167.  
  168.  
  169.  
  170.  
  171.  
  172.  
  173.  
  174.  
  175.  
  176.  
  177.  
  178.  
  179.  
  180.  
  181.  
  182.  
  183.  
  184.  
  185.  
  186.  
  187.  
  188.  
  189.  
  190.  
  191.  
  192.  
  193.  
  194.  
  195.                                    D - 2
  196.  
  197.  
  198.  
  199.  
  200.  
  201.  
  202.  
  203.  
  204. Composite  type.   A  composite  type  is one whose values have components.
  205. There are two kinds of composite type:  array types and record types.
  206.  
  207. Constant.  See object.
  208.  
  209. Constraint.  A constraint determines a subset of the values of a  type.   A
  210. value in that subset satisfies the constraint.
  211.  
  212. Context clause.  See compilation unit.
  213.  
  214. Declaration.   A  declaration  associates  an  identifier  (or  some  other
  215. notation) with an entity.  This association is in effect within a region of
  216. text  called  the  scope  of  the  declaration.   Within  the  scope  of  a
  217. declaration, there are places where it is possible to use the identifier to
  218. refer  to the associated declared entity.  At such places the identifier is
  219. said to be a simple name of the entity;  the name is  said  to  denote  the
  220. associated entity.
  221.  
  222. Declarative  Part.   A  declarative part is a sequence of declarations.  It
  223. may  also  contain  related  information  such  as  subprogram  bodies  and
  224. representation clauses.
  225.  
  226. Denote.  See declaration.
  227.  
  228. Derived  Type.   A  derived  type is a type whose operations and values are
  229. replicas of those of an existing type.  The existing  type  is  called  the
  230. parent type of the derived type.
  231.  
  232. Designate.  See access type, task.
  233.  
  234. Direct visibility.  See visibility.
  235.  
  236. Discrete  Type.   A  discrete  type  is  a type which has an ordered set of
  237. distinct values.  The discrete types are the enumeration and integer types.
  238. Discrete types are used for indexing and iteration, and for choices in case
  239. statements and record variants.
  240.  
  241. Discriminant.  A discriminant is a distinguished component of an object  or
  242. value  of  a  record type.  The subtypes of other components, or even their
  243. presence or absence, may depend on the value of the discriminant.
  244.  
  245. Discriminant constraint.  A discriminant constraint on  a  record  type  or
  246. private type specifies a value for each discriminant of the type.
  247.  
  248. Elaboration.   The elaboration of a declaration is the process by which the
  249. declaration achieves its effect (such as creating an object);  this process
  250. occurs during program execution.
  251.  
  252. Entry.  An entry is used for communication between tasks.  Externally,   an
  253. entry  is  called just as a subprogram is called;  its internal behavior is
  254. specified by one or more accept statements specifying  the  actions  to  be
  255. performed when the entry is called.
  256.  
  257. Enumeration type.  An enumeration type is a discrete  type whose values are
  258. represented  by enumeration literals which are given explicitly in the type
  259.  
  260.  
  261.                                    D - 3
  262.  
  263.  
  264.  
  265.  
  266.  
  267.  
  268.  
  269.  
  270. declaration.   These  enumeration  literals  are  either   identifiers   or
  271. character literals.
  272.  
  273. Evaluation.   The  evaluation  of an expression is the process by which the
  274. value of the expression is computed.  This process  occurs  during  program
  275. execution.
  276.  
  277. Exception.   An  exception  is  an  error  situation which may arise during
  278. program execution.  To raise an exception  is  to  abandon  normal  program
  279. execution  so  as  to  signal that the error has taken place.  An exception
  280. handler is  a  portion  of  program  text  specifying  a  response  to  the
  281. exception.   Execution  of  such  a  program  text  is  called handling the
  282. exception.
  283.  
  284.  
  285.  
  286.  
  287.  
  288.  
  289.  
  290.  
  291.  
  292.  
  293.  
  294.  
  295.  
  296.  
  297.  
  298.  
  299.  
  300.  
  301.  
  302.  
  303.  
  304.  
  305.  
  306.  
  307.  
  308.  
  309.  
  310.  
  311.  
  312.  
  313.  
  314.  
  315.  
  316.  
  317.  
  318.  
  319.  
  320.  
  321.  
  322.  
  323.  
  324.  
  325.  
  326.  
  327.                                    D - 4
  328.  
  329.  
  330.  
  331.  
  332.  
  333.  
  334.  
  335.  
  336. Expanded name.  An expanded  name  denotes  an  entity  which  is  declared
  337. immediately  within  some  construct.   An  expanded name has the form of a
  338. selected component:  the prefix denotes the construct (a program unit;   or
  339. a  block,  loop,  or accept statement);  the selector is the simple name of
  340. the entity.
  341.  
  342. Expression.  An expression defines the computation of a value.
  343.  
  344. Fixed point type.  See real type.
  345.  
  346. Floating point type.  See real type.
  347.  
  348. Formal parameter.  See parameter.
  349.  
  350. Function.  See subprogram.
  351.  
  352. Generic unit.  A generic unit is a template either for a set of subprograms
  353. or for a set of packages.   A  subprogram  or  package  created  using  the
  354. template   is   called   an  instance  of  the  generic  unit.   A  generic
  355. instantiation is the kind of  declaration  that  creates  an  instance.   A
  356. generic   unit  is  written  as  a  subprog